package org.ala.linshen.dp;

import java.util.Arrays;
import java.util.List;

/**
 * 给你一个下标从 0 开始的整数数组 nums 和一个整数 target 。
 *
 * 返回和为 target 的 nums 子序列中，子序列 长度的最大值 。如果不存在和为 target 的子序列，返回 -1 。
 *
 * 子序列 指的是从原数组中删除一些或者不删除任何元素后，剩余元素保持原来的顺序构成的数组。
 *
 *
 *
 * 示例 1：
 *
 * 输入：nums = [1,2,3,4,5], target = 9
 * 输出：3
 * 解释：总共有 3 个子序列的和为 9 ：[4,5] ，[1,3,5] 和 [2,3,4] 。最长的子序列是 [1,3,5] 和 [2,3,4] 。所以答案为 3 。
 * 示例 2：
 *
 * 输入：nums = [4,1,3,2,1,5], target = 7
 * 输出：4
 * 解释：总共有 5 个子序列的和为 7 ：[4,3] ，[4,1,2] ，[4,2,1] ，[1,1,5] 和 [1,3,2,1] 。最长子序列为 [1,3,2,1] 。所以答案为 4 。
 * 示例 3：
 *
 * 输入：nums = [1,1,5,4,5], target = 3
 * 输出：-1
 * 解释：无法得到和为 3 的子序列。
 *
 *
 * 提示：
 *
 * 1 <= nums.length <= 1000
 * 1 <= nums[i] <= 1000
 * 1 <= target <= 1000
 *
 * @author ala
 * @date 2024-09-27 17:44
 */
public class Q2915 {

    public static void main(String[] args) {
        Q2915 q = new Q2915();

//        List<Integer> nums = Arrays.asList(1,2,3,4,5);
//        int target = 9;

//        List<Integer> nums = Arrays.asList(2,13,7,3,14,8,11,10,7,13);
//        int target = 44;

        List<Integer> nums = Arrays.asList(1,1,5,4,5);
        int target = 3;

        System.out.println(q.lengthOfLongestSubsequence(nums, target));
    }

    public int lengthOfLongestSubsequence(List<Integer> nums, int target) {
        return V1(nums, target);
    }

    /**
     *  1）dp[i]表示：和为i的最大长度
     *  2）dp[i] = max(dp[i - nums[j]] + 1)
     *  3）dp[0] = 0，dp[target]就是答案
     */
    protected int V1(List<Integer> nums, int target) {
        int N = nums.size();
        int[] dp = new int[target + 1];
        Arrays.fill(dp, Integer.MIN_VALUE >> 1);
        dp[0] = 0;
        for (int n : nums) {
            for (int i = target ; i >= n ; i--) {
                dp[i] = Math.max(dp[i], dp[i - n] + 1);
            }
        }
        return dp[target] > 0 ? dp[target] : -1;
    }
}
